import math



class A:
    bar = 1

    @staticmethod
    def f():
        print(" super: @staticmethod")

    def call(self):
        return 0

    @classmethod
    def classMeth(cls):
        print("@classmethod")


class B(A):
    @staticmethod
    def f():
        print("sub: @staticmethod")

    def superF(self):
        print(super().f())


class C:
    def __init__(self):
        self._x = None
        self._y = None

    def getX(self):
        return self._x

    def setX(self, value):
        self._x = value

    def delX(self):
        pass

    @property
    def y(self):
        return self._y

    @y.setter
    def y(self, value):
        self._y = value

    @y.deleter
    def y(self):
        del self._y

    x = property(getX, setX, delX, "I'm the 'x' property.")


if __name__ == "__main__":
    # abs()函数返回数字的绝对值。
    print("abs(-40) : ", abs(-40))
    print("abs(100.10) : ", abs(100.10))

    # Python dict() 函数用于创建一个字典。
    dict(a='a', b='b', t='t')
    dict(zip(['one', 'two', 'three'], [1, 2, 3]))
    dict([('one', 1), ('tow', 2), ('three', 3)])

    # Python help() 函数用于查看函数或模块用途的详细说明
    # help('sys')
    # help('str')
    a = [1, 2, 3]
    # help(a)
    # min() 方法返回给定参数的最小值，参数可以为序列。
    min(1, 2, 3, 4)
    min([32, 123, 11, 3, 32])
    min((12, 32, 12, 23, 32, 321, 2))

    # Python setattr() 函数对应函数 getattr()，用于设置属性值，该属性不一定是存在的。
    a = A()
    getattr(a, 'bar')
    setattr(a, 'bar', 22)

    # all()函数用于判断一个列表中的所有元素是否为真（True）。
    print(all(['a', 'b', 'c']))
    print(all(['a', '', 'c']))
    print(all(('1', '2', '')))
    print(all([]))

    # Python dir 函数不带参数时，返回当前作用域内的所有名称；
    print(dir())
    print(dir([]))

    # Python3 hex() 函数用于将一个指定数字转换为 16 进制数。
    print(hex(255))
    print(hex(-42))

    # Python next() 返回迭代器的下一个项目。
    it = iter([1, 2, 'a', 'b'])
    while True:
        try:
            x = next(it)
            print(x)
        except StopIteration:
            break

    # Python slice() 函数实现切片对象，主要用在切片操作函数里的参数传递。
    mySlice = slice(5)
    print(mySlice)
    arr = range(10)
    print(arr[mySlice])

    # any() 函数用于判断一个列表中的所有元素是否为假（False）。
    print(any(['a', 'b', 'c', 'd']))
    print(any(['a', 'b', '', 'd']))
    print(any([0, "", False, None]))
    print(any((0, "", False, None, 1)))
    print(any(()))

    # python divmod() 函数把除数和余数运算结果结合起来，返回一个包含商和余数的元组(a // b, a % b)。
    print(divmod(7, 2))

    # id()函数用于返回对象的唯一标识符，通常情况下，这个唯一标识符是这个对象的内存地址。
    print(id("test"))

    # sorted() 函数对所有可迭代的对象进行排序操作。
    sorted([5, 2, 3, 1, 4])
    sorted([5, 2, 3, 1, 4], reverse=True)

    a = [5, 2, 3, 1, 4]
    a.sort()
    print(a)

    # Python3 ascii() 函数类似 repr() 函数, 返回一个表示对象的字符串
    print(ascii("w3cschool"))

    # Python3 enumerate() 函数用于将一个可遍历的数据对象
    seasons = ['Spring', 'Summer', 'Fall', 'Winter']
    print(list(seasons))
    print(list(enumerate(seasons)))

    # Python3.x 中 input() 函数接受一个标准输入数据，返回为 string 类型
    # a = input("input:")

    # Python oct() 函数将一个整数转换成8进制字符串。
    print(oct(10))

    # Python staticmethod 返回函数的静态方法
    a = A()
    A.f()
    a.f()

    # Python bin() 返回一个整数 int 或者长整数 long int 的二进制表示。
    print(bin(10))

    # Python eval()函数用来执行一条字符串中的python表达式，并返回表达式的值。
    x = 7
    print(eval('3 * 7 - 1'))
    eval("pow(2, 2)")

    # Python int() 函数用于将一个字符串或数字转换为整型。
    print(int())
    print(int("333"))
    print(int('0xa', 16))

    # Python3 open() 方法用于打开一个文件，并返回文件对象，在对文件进行处理过程都需要使用到这个函数，如果该文件无法被打开，会抛出
    # f = open('test.txt')

    # Python str() 函数将对象转化为适于人阅读的形式。
    str("w3cschool")
    dict = {'w3cschool': 'w3cschool', 'google': 'google.com'}
    print(str(dict))

    # Python bool() 函数用于将给定参数转换为布尔类型，如果没有参数，返回 False。
    print(bool(0))
    print(bool('a'))
    print(issubclass(bool, int))

    # Python3 exec 执行储存在字符串或文件中的 Python 语句，相比于 eval，exec可以执行更复杂的 Python 代码。
    exec('print("hello world")')
    exec("""for i in range(5):
        print("iter time: %d" % i)
    """)

    # Python isinstance() 函数来判断一个对象是否是一个已知的类型，类似 type()。
    """
    type() 不会认为子类是一种父类类型，不考虑继承关系。
    isinstance() 会认为子类是一种父类类型，考虑继承关系。
    """
    a = 2
    print(isinstance(a, int))
    print(isinstance(A(), A))
    print(type(A()) == A)

    # Python3 ord() 函数是 chr() 函数（对于 8 位的 ASCII 字符串）的配对函数，它以一个字符串（Unicode 字符）作为参数，返回对应的 ASCII 数值，或者 Unicode 数值。
    print(ord('a'))

    # Python sum() 方法对系列进行求和计算。
    print(sum([0, 1, 2]))
    print(sum([0, 1, 2], 4))

    # Python bytearray() 方法返回一个新字节数组。这个数组里的元素是可变的，并且每个元素的值范围: 0 <= x < 256
    print(bytearray())
    print(bytearray([1, 2, 3]))
    print(bytearray(b'\x01\x02\x03'))

    # filter() 函数用于过滤序列，过滤掉不符合条件的元素
    li = [1, 2, 3, 4, 5, 6, 7, 8, 9]
    tmplist = filter(lambda n: n % 2 == 0, li)
    print(list(tmplist))

    li = ["", "1", "3", False, 0]
    print(list(filter(None, li)))
    a = []

    b = B()
    print(issubclass(B, A))
    print(isinstance(b, A))
    print(type(b) == A)

    # pow()方法返回 xy（x的y次方） 的值。
    print(math.pow(2, 3))
    print(2 ** 3)

    # Python super() 函数是用于调用父类(超类)的一个方法
    """
    super 是用来解决多重继承问题的，直接用类名调用父类方法在使用单继承的时候没问题，但是如果使用多继承，会涉及到查找顺序（MRO）、重复调用（钻石继承）等种种问题。
    MRO 就是类的方法解析顺序表, 其实也就是继承父类方法时的顺序表
    """

    print(b.f())
    print(b.superF())

    # Python3 bytes 函数返回一个新的 bytes 对象，该对象是一个 0 <= x < 256 区间内的整数不可变序列。它是 bytearray 的不可变版本。
    print(bytes([1, 2, 3]))

    # Python float() 函数用于将整数和字符串转换成浮点数。
    print(float(1))

    # Python3 tuple 函数将列表转换为元组。。
    print(tuple([1, 2, 3, 4]))

    # Python callable() 函数用于检查一个对象是否是可调用的。如果返回 True，object 仍然可能调用失败；但如果返回 False，调用对象 object 绝对不会成功。
    # 对于函数、方法、lambda 函式、 类以及实现了 __call__ 方法的类实例，它都返回 True。
    print(callable(0))
    print(callable(A))
    print(callable(A().call))

    # format 它增强了字符串格式化的功能
    "{} {}".format("hello", "world")  # 不设置指定位置，按默认顺序
    print("{1}, {0}, {1}".format("hello", "你好"))
    print("{} 对应的位置是 {{0}}".format("school"))

    # len() 方法返回一个对象的长度（元素个数），这里的对象可以是序列（如 string、bytes、tuple、list 或 range 等），也可以是集合（如 dictionary、set 或 frozen set 等）。
    print(len("example str"))
    print(len([1, 2, 3]))
    print(len({1: 'a', b: {2}, 3: 5}))

    # Python property() 函数的作用是在新式类中返回属性值。
    c = C()
    c.x = "aaa"
    print(c.x)
    c.y = "yyy"
    print(c.y)

    # type() 函数通常被用来判断对象的类型
    print(type(A))
    print(type([1, 2, 3]))

    # Python3 chr() 用一个整数作参数，返回一个对应的字符。
    print(chr(49))
    print(chr(0x30))

    # Python frozenset() 返回一个冻结的集合，冻结后集合不能再添加或删除任何元素。
    ran = frozenset(range(10))
    dic = frozenset([1, 2, 3, 4])
    # dic[{5: "5"}]

    # list() 方法用于将序列（元组，集合，字符串等）转换为列表。
    aTuple = (123, 'Google', 'W3CSchool', 'Taobao')
    print(list(aTuple))
    print(list("abcd123"))

    # Python3 range() 函数返回的是一个可迭代对象（类型是对象），而不是列表类型， 所以打印的时候不会打印列表
    ran = range(5)
    print(ran)
    print(list(ran))
    print(list(range(0, 30, 5)))

    # Python vars() 函数返回对象object的属性和属性值的字典对象。
    print(vars())

    # Python classmethod 修饰符对应的函数不需要实例化，不需要 self 参数，但第一个参数需要是表示自身类的 cls 参数，可以来调用类的属性，类的方法，实例化对象等。
    A.classMeth()

    # Python getattr() 函数用于返回一个对象属性值。
    a = A()
    print(getattr(a, "bar"))

    # Python locals() 函数会以字典类型返回当前位置的全部局部变量。
    print(locals())

    # Python repr() 函数将对象转化为供解释器读取的形式。
    print(repr("W3cschool.cn"))
    print(repr({'w3cschool': 'w3cschool.cn', 'google': 'google.com'}))

    # Python3 zip() 函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的对象，这样做的好处是节约了不少的内存。
    a = [1, 2, 3]
    b = [4, 5, 6]
    zipped = zip(a, b)
    print(list(zipped))
    c, d = zip(*zip(a, b))
    print(c)

    # Python compile() 函数将一个字符串编译为字节代码。
    str = "for i in range(0, 10): print(i)"
    c = compile(str, "", "exec")
    print(c)
    exec(c)

    # Python hasattr() 函数用于判断对象是否包含对应的属性。
    a = A()
    print(hasattr(a, "bar"))
    print(hasattr(a, "bar1"))

    # Python globals() 函数会以字典类型返回当前位置的全部全局变量。
    print(globals())

    # Python map() 会根据提供的函数对指定序列做映射

    print(list(map(lambda x: x ** 2, [1, 2, 3, 4, 5])))
    print(list(map(lambda x, y: x + y, [1, 2, 3, 4, 5], [1, 2, 3, 4, 5])))

    # Python3 reversed 函数返回一个反转的迭代器。
    print(list(reversed("123456")))
    print(list(reversed((range(5, 9)))))

    # Python __import__() 函数用于动态加载类和函数 。
    __import__('a')

    # Python complex() 函数用于创建一个值为 real + imag * j 的复数或者转化一个字符串或数为复数。如果第一个参数为字符串，则不需要指定第二个
    print(complex(1, 2))
    print(complex("1"))
    print(complex("1+2j"))

    # max()方法返回给定参数的最大值，参数可以为序列。
    print("max(80, 100, 1000) : ", max(80, 100, 1000))

    # round()方法返回浮点数x的四舍五入值。
    print("round(70.23456) : ", round(70.23456))
    print("round(56.659,1) : ", round(56.659, 1))
    print ("round(80.264, 2) : ", round(80.264, 2))

    #Python delattr 函数用于删除属性。
    a = A()
    print(a.bar)
    # delattr(a, "bar")
    print(a.bar)

    # Python hash() 用于获取取一个对象（字符串或者数值等）的哈希值。
    print(hash("test"))

    # Python memoryview() 函数返回给定参数的内存查看对象(Momory view)
    v = memoryview(bytearray("abcefg", 'utf-8'))
    print(v[1])
    print(v[-1])
    print(v[1:4].tobytes())

    # Python set() 函数创建一个无序不重复元素集，可进行关系测试，删除重复数据，还可以计算交集、差集、并集等。
    print(set("school"))
    x, y = set(['c', 'h', 'l', 'o', 's']), set(['e', 'o', 'g', 'l'])
    print(x & y)